package com.wicket.okrcalc.web.contorller;

import cn.hutool.core.bean.BeanUtil;
import com.github.pagehelper.Page;
import com.github.pagehelper.page.PageMethod;
import com.wicket.okrcalc.biz.service.StandardDataService;
import com.wicket.okrcalc.biz.service.dto.req.*;
import com.wicket.okrcalc.biz.service.dto.res.*;
import com.wicket.okrcalc.common.ro.OkrResult;
import com.wicket.okrcalc.common.util.CommonFunctionHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author ：
 * @date ：
 *
 *
 * @version 1.0
 */
@RestController
@RequestMapping("/calc/standardData/")
public class StandardDataController {

  @Autowired
  StandardDataService standardDataService;
/**
   * D4-1批量查标准数据列表
   */
    @PostMapping("batchQueryStandardDataList")
    public OkrResult<BatchQueryStandardDataListRespDto> batchQueryStandardDataList(@RequestBody @Validated BatchQueryStandardDataListReqDto reqDTO){
    return OkrResult.success(standardDataService.batchQueryStandardDataList(reqDTO));
    }
/**
   * D4-1批量查询切片评价模板标准数据(公共)
   */
    @PostMapping("batchQuerySectionEvaStandardDataCom")
    public OkrResult<BatchQuerySectionEvaStandardDataComRespDto> batchQuerySectionEvaStandardDataCom(@RequestBody @Validated BatchQuerySectionEvaStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.batchQuerySectionEvaStandardDataCom(reqDTO));
    }
/**
   * D4-1查询评价模板标准数据列表(公共)
   */
    @PostMapping("queryEvaStandardDataListCom")
    public OkrResult<QueryEvaStandardDataListComRespDto> queryEvaStandardDataListCom(@RequestBody @Validated QueryEvaStandardDataListComReqDto reqDTO){
    Page<?> page = CommonFunctionHelper.startPage(reqDTO.getPageNum(),reqDTO.getPageSize());

        QueryEvaStandardDataListComRespDto retData = standardDataService.queryEvaStandardDataListCom(reqDTO);

        retData.setPageNum(page.getPageNum());
        retData.setPageSize(page.getPageSize());
        retData.setTotalNum(page.getTotal());
        return OkrResult.success(retData);
    
    }
/**
   * D4-1查询评价模板标准数据详情(公共)
   */
    @PostMapping("queryEvaStandardDataDetailCom")
    public OkrResult<QueryEvaStandardDataDetailComRespDto> queryEvaStandardDataDetailCom(@RequestBody @Validated QueryEvaStandardDataDetailComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryEvaStandardDataDetailCom(reqDTO));
    }
/**
   * 待确认删除--D4-查询四棵树数据准备详情(公共)
   */
    @PostMapping("queryPrepareForOtherTreeDetailCom")
    public OkrResult<QueryPrepareForOtherTreeDetailComRespDto> queryPrepareForOtherTreeDetailCom(@RequestBody @Validated QueryPrepareForOtherTreeDetailComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryPrepareForOtherTreeDetailCom(reqDTO));
    }
/**
   * D4-查询标准数据列表ByCodes(公共)
   */
    @PostMapping("batchQueryStandardDataListByCodesCom")
    public OkrResult<BatchQueryStandardDataListByCodesComRespDto> batchQueryStandardDataListByCodesCom(@RequestBody @Validated BatchQueryStandardDataListByCodesComReqDto reqDTO){
    return OkrResult.success(standardDataService.batchQueryStandardDataListByCodesCom(reqDTO));
    }
/**
   * D4-查询计算准备的同级权重数据列表(公共)
   */
    @PostMapping("queryPrepareForLevelWeightDataListCom")
    public OkrResult<QueryPrepareForLevelWeightDataListComRespDto> queryPrepareForLevelWeightDataListCom(@RequestBody @Validated QueryPrepareForLevelWeightDataListComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryPrepareForLevelWeightDataListCom(reqDTO));
    }
/**
   * D4-查询子周期类型被评对象目标周期标准数据列表(公共)
   */
    @PostMapping("querySubCycEvaObjTargetCycleDataListCom")
    public OkrResult<QuerySubCycEvaObjTargetCycleDataListComRespDto> querySubCycEvaObjTargetCycleDataListCom(@RequestBody @Validated QuerySubCycEvaObjTargetCycleDataListComReqDto reqDTO){
    return OkrResult.success(standardDataService.querySubCycEvaObjTargetCycleDataListCom(reqDTO));
    }
/**
   * D4-更新四棵树标准数据(公共)
   */
    @PostMapping("refreshOtherTreeStandardDataCom")
    public OkrResult<RefreshOtherTreeStandardDataComRespDto> refreshOtherTreeStandardDataCom(@RequestBody @Validated RefreshOtherTreeStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.refreshOtherTreeStandardDataCom(reqDTO));
    }
/**
   * D4-查询计算准备的标准数据详情(公共)
   */
    @PostMapping("queryPrepareForStandardDataDetailCom")
    public OkrResult<QueryPrepareForStandardDataDetailComRespDto> queryPrepareForStandardDataDetailCom(@RequestBody @Validated QueryPrepareForStandardDataDetailComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryPrepareForStandardDataDetailCom(reqDTO));
    }
/**
   * D4-查询计算准备的权重数据详情(公共)
   */
    @PostMapping("queryPrepareForWeightDataDetailCom")
    public OkrResult<QueryPrepareForWeightDataDetailComRespDto> queryPrepareForWeightDataDetailCom(@RequestBody @Validated QueryPrepareForWeightDataDetailComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryPrepareForWeightDataDetailCom(reqDTO));
    }
/**
   * D4-1更新标准数据(公共)
   */
    @PostMapping("refreshStandardDataCom")
    public OkrResult<RefreshStandardDataComRespDto> refreshStandardDataCom(@RequestBody @Validated RefreshStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.refreshStandardDataCom(reqDTO));
    }
/**
   * D4-计算并新增跨周期达成度标准数据(公共)
   */
    @PostMapping("calculateAndCreateCrossCycleReachCom")
    public OkrResult<CalculateAndCreateCrossCycleReachComRespDto> calculateAndCreateCrossCycleReachCom(@RequestBody @Validated CalculateAndCreateCrossCycleReachComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateAndCreateCrossCycleReachCom(reqDTO));
    }

/**
   * D4-计算并新增本级得分标准数据(公共)
   */
    @PostMapping("calculateAndCreateLocalLevelScoreStandardDataCom")
    public OkrResult<CalculateAndCreateLocalLevelScoreStandardDataComRespDto> calculateAndCreateLocalLevelScoreStandardDataCom(@RequestBody @Validated CalculateAndCreateLocalLevelScoreStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateAndCreateLocalLevelScoreStandardDataCom(reqDTO));
    }

/**
   * D4-计算并新增过程主观得分标准数据(公共)
   */
    @PostMapping("calculateAndCreateProcessSubjectiveScoreStandardDataCom")
    public OkrResult<CalculateAndCreateProcessSubjectiveScoreStandardDataComRespDto> calculateAndCreateProcessSubjectiveScoreStandardDataCom(@RequestBody @Validated CalculateAndCreateProcessSubjectiveScoreStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateAndCreateProcessSubjectiveScoreStandardDataCom(reqDTO));
    }


/**
   * D4-计算并新增跨周期数据集取最新类型标准数据(公共)
   */
    @PostMapping("calculateAndCreateCrossCycleNewestOfMultipleNumCom")
    public OkrResult<CalculateAndCreateCrossCycleNewestOfMultipleNumComRespDto> calculateAndCreateCrossCycleNewestOfMultipleNumCom(@RequestBody @Validated CalculateAndCreateCrossCycleNewestOfMultipleNumComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateAndCreateCrossCycleNewestOfMultipleNumCom(reqDTO));
    }


/**
   * D4-计算并新增当前主观得分标准数据(公共)
   */
    @PostMapping("calculateAndCreateCurSubjectiveScoreStandardDataCom")
    public OkrResult<CalculateAndCreateCurSubjectiveScoreStandardDataComRespDto> calculateAndCreateCurSubjectiveScoreStandardDataCom(@RequestBody @Validated CalculateAndCreateCurSubjectiveScoreStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateAndCreateCurSubjectiveScoreStandardDataCom(reqDTO));
    }
/**
   * D4-计算并新增角色主观得分标准数据(公共)
   */
    @PostMapping("calculateAndCreateRoleSubjectiveScoreStandardDataCom")
    public OkrResult<CalculateAndCreateRoleSubjectiveScoreStandardDataComRespDto> calculateAndCreateRoleSubjectiveScoreStandardDataCom(@RequestBody @Validated CalculateAndCreateRoleSubjectiveScoreStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateAndCreateRoleSubjectiveScoreStandardDataCom(reqDTO));
    }

/**
   * D4-计算并新增跨层级数据集复合算法类型标准数据(公共)
   */
    @PostMapping("calculateAndCreateCrossLevelComplexCalcOfMultipleNumCom")
    public OkrResult<CalculateAndCreateCrossLevelComplexCalcOfMultipleNumComRespDto> calculateAndCreateCrossLevelComplexCalcOfMultipleNumCom(@RequestBody @Validated CalculateAndCreateCrossLevelComplexCalcOfMultipleNumComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateAndCreateCrossLevelComplexCalcOfMultipleNumCom(reqDTO));
    }

/**
   * D4-计算并新增两个数相减类型标准数据(公共)
   */
    @PostMapping("calculateAndCreateSubtractionOfTwoNumCom")
    public OkrResult<CalculateAndCreateSubtractionOfTwoNumComRespDto> calculateAndCreateSubtractionOfTwoNumCom(@RequestBody @Validated CalculateAndCreateSubtractionOfTwoNumComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateAndCreateSubtractionOfTwoNumCom(reqDTO));
    }
/**
   * D4-计算并新增达成度标准数据(公共)
   */
    @PostMapping("calculateAndCreateReachStandardDataCom")
    public OkrResult<CalculateAndCreateReachStandardDataComRespDto> calculateAndCreateReachStandardDataCom(@RequestBody @Validated CalculateAndCreateReachStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateAndCreateReachStandardDataCom(reqDTO));
    }
/**
   * D4-计算上级目标值标准数据(公共)
   */
    @PostMapping("calculateParentTargetStandardDataCom")
    public OkrResult<CalculateParentTargetStandardDataComRespDto> calculateParentTargetStandardDataCom(@RequestBody @Validated CalculateParentTargetStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateParentTargetStandardDataCom(reqDTO));
    }
/**
   * D4-计算上级进度值标准数据(公共)
   */
    @PostMapping("calculateParentProgressStandardDataCom")
    public OkrResult<CalculateParentProgressStandardDataComRespDto> calculateParentProgressStandardDataCom(@RequestBody @Validated CalculateParentProgressStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateParentProgressStandardDataCom(reqDTO));
    }
/**
   * D4-计算跨周期达成度标准数据(公共)
   */
    @PostMapping("calculateCrossCycleReachCom")
    public OkrResult<CalculateCrossCycleReachComRespDto> calculateCrossCycleReachCom(@RequestBody @Validated CalculateCrossCycleReachComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateCrossCycleReachCom(reqDTO));
    }
/**
   * D4-计算跨周期目标值标准数据(公共)
   */
    @PostMapping("calculateCrossCycleTargetStandardDataCom")
    public OkrResult<CalculateCrossCycleTargetStandardDataComRespDto> calculateCrossCycleTargetStandardDataCom(@RequestBody @Validated CalculateCrossCycleTargetStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateCrossCycleTargetStandardDataCom(reqDTO));
    }
/**
   * D4-计算跨周期进度值标准数据(公共)
   */
    @PostMapping("calculateCrossCycleProgressStandardDataCom")
    public OkrResult<CalculateCrossCycleProgressStandardDataComRespDto> calculateCrossCycleProgressStandardDataCom(@RequestBody @Validated CalculateCrossCycleProgressStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateCrossCycleProgressStandardDataCom(reqDTO));
    }
/**
   * D4-计算达成度标准数据(公共)
   */
    @PostMapping("calculateReachStandardDataCom")
    public OkrResult<CalculateReachStandardDataComRespDto> calculateReachStandardDataCom(@RequestBody @Validated CalculateReachStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateReachStandardDataCom(reqDTO));
    }

/**
   * D4-计算当前周期目标值标准数据(公共)
   */
    @PostMapping("calculateCurrentTargetStandardDataCom")
    public OkrResult<CalculateCurrentTargetStandardDataComRespDto> calculateCurrentTargetStandardDataCom(@RequestBody @Validated CalculateCurrentTargetStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateCurrentTargetStandardDataCom(reqDTO));
    }
/**
   * D4-计算当前周期进度值标准数据(公共)
   */
    @PostMapping("calculateCurrentProgressStandardDataCom")
    public OkrResult<CalculateCurrentProgressStandardDataComRespDto> calculateCurrentProgressStandardDataCom(@RequestBody @Validated CalculateCurrentProgressStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateCurrentProgressStandardDataCom(reqDTO));
    }
/**
   * D4-计算上级标准数据(公共)
   */
    @PostMapping("calculateParentStandardDataCom")
    public OkrResult<CalculateParentStandardDataComRespDto> calculateParentStandardDataCom(@RequestBody @Validated CalculateParentStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateParentStandardDataCom(reqDTO));
    }
/**
   * D4-计算父执行周期当前标准数据(公共)
   */
    @PostMapping("calculateFatExeCycCurStandardDataCom")
    public OkrResult<CalculateFatExeCycCurStandardDataComRespDto> calculateFatExeCycCurStandardDataCom(@RequestBody @Validated CalculateFatExeCycCurStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateFatExeCycCurStandardDataCom(reqDTO));
    }

/**
   * D4-计算父执行周期标准数据(公共)----待调整
   */
    @PostMapping("calculateFatExeStandardDataCom")
    public OkrResult<CalculateFatExeStandardDataComRespDto> calculateFatExeStandardDataCom(@RequestBody @Validated CalculateFatExeStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateFatExeStandardDataCom(reqDTO));
    }

/**
   * D4-批量删标准数据(公共)
   */
    @PostMapping("batchDeleteStandardDataCom")
    public OkrResult<BatchDeleteStandardDataComRespDto> batchDeleteStandardDataCom(@RequestBody @Validated BatchDeleteStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.batchDeleteStandardDataCom(reqDTO));
    }
/**
   * D4-1查询标准数据列表(公共)
   */
    @PostMapping("queryStandardDataListCom")
    public OkrResult<QueryStandardDataListComRespDto> queryStandardDataListCom(@RequestBody @Validated QueryStandardDataListComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryStandardDataListCom(reqDTO));
    }
/**
   * D4-1查询被评对象目标周期标准数据详情(公共)
   */
    @PostMapping("queryEvaObjTargetCycleDataDetailCom")
    public OkrResult<QueryEvaObjTargetCycleDataDetailComRespDto> queryEvaObjTargetCycleDataDetailCom(@RequestBody @Validated QueryEvaObjTargetCycleDataDetailComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryEvaObjTargetCycleDataDetailCom(reqDTO));
    }
/**
   * D4-1查标准数据详情(公共)
   */
    @PostMapping("queryStandardDataDetailCom")
    public OkrResult<QueryStandardDataDetailComRespDto> queryStandardDataDetailCom(@RequestBody @Validated QueryStandardDataDetailComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryStandardDataDetailCom(reqDTO));
    }
/**
   * D4-查询过滤后标准数据列表(公共)
   */
    @PostMapping("queryFiltrationStandardDataListCom")
    public OkrResult<QueryFiltrationStandardDataListComRespDto> queryFiltrationStandardDataListCom(@RequestBody @Validated QueryFiltrationStandardDataListComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryFiltrationStandardDataListCom(reqDTO));
    }
/**
   * D4-查询通过周期阶段资料过滤后标准数据列表(公共)
   */
    @PostMapping("queryFiltrationStandardDataByStageDataListCom")
    public OkrResult<QueryFiltrationStandardDataByStageDataListComRespDto> queryFiltrationStandardDataByStageDataListCom(@RequestBody @Validated QueryFiltrationStandardDataByStageDataListComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryFiltrationStandardDataByStageDataListCom(reqDTO));
    }
/**
   * D4-1删除被评对象目标周期标准数据(公共)
   */
    @PostMapping("deleteEvaObjTargetCycleDataCom")
    public OkrResult<DeleteEvaObjTargetCycleDataComRespDto> deleteEvaObjTargetCycleDataCom(@RequestBody @Validated DeleteEvaObjTargetCycleDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.deleteEvaObjTargetCycleDataCom(reqDTO));
    }

/**
   * D4-计算并新增部门目标任务书标准数据(公共)
   */
    @PostMapping("calculateAndCreateDeptObjMisStaDataCom")
    public OkrResult<CalculateAndCreateDeptObjMisStaDataComRespDto> calculateAndCreateDeptObjMisStaDataCom(@RequestBody @Validated CalculateAndCreateDeptObjMisStaDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateAndCreateDeptObjMisStaDataCom(reqDTO));
    }

/**
   * D4-执行主观评分标准数据校验(公共)
   */
    @PostMapping("implementVerifySubjectiveScoreStandardDataCom")
    public OkrResult<ImplementVerifySubjectiveScoreStandardDataComRespDto> implementVerifySubjectiveScoreStandardDataCom(@RequestBody @Validated ImplementVerifySubjectiveScoreStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.implementVerifySubjectiveScoreStandardDataCom(reqDTO));
    }
/**
   * D4-执行进度值标准数据校验(公共)
   */
    @PostMapping("implementVerifyProgressStandardDataCom")
    public OkrResult<ImplementVerifyProgressStandardDataComRespDto> implementVerifyProgressStandardDataCom(@RequestBody @Validated ImplementVerifyProgressStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.implementVerifyProgressStandardDataCom(reqDTO));
    }
/**
   * D4-执行目标值标准数据校验(公共)
   */
    @PostMapping("implementVerifyTargetStandardDataCom")
    public OkrResult<ImplementVerifyTargetStandardDataComRespDto> implementVerifyTargetStandardDataCom(@RequestBody @Validated ImplementVerifyTargetStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.implementVerifyTargetStandardDataCom(reqDTO));
    }
/**
   * D4-批量增标准数据(公共)
   */
    @PostMapping("batchAddStandardDataCom")
    public OkrResult<BatchAddStandardDataComRespDto> batchAddStandardDataCom(@RequestBody @Validated BatchAddStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.batchAddStandardDataCom(reqDTO));
    }
/**
   * D4-查询计算准备的权重数据列表(公共)
   */
    @PostMapping("queryPrepareForWeightDataListCom")
    public OkrResult<QueryPrepareForWeightDataListComRespDto> queryPrepareForWeightDataListCom(@RequestBody @Validated QueryPrepareForWeightDataListComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryPrepareForWeightDataListCom(reqDTO));
    }
/**
   * D4查询组织或人匹配标准数据列表(公共)
   */
    @PostMapping("queryOrgOrMatchingStandardDataListCom")
    public OkrResult<QueryOrgOrMatchingStandardDataListComRespDto> queryOrgOrMatchingStandardDataListCom(@RequestBody @Validated QueryOrgOrMatchingStandardDataListComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryOrgOrMatchingStandardDataListCom(reqDTO));
    }
/**
   * D4-1批量查询标准数据by评价人(公共)
   */
    @PostMapping("batchQueryStandardDataByEvaluateCom")
    public OkrResult<BatchQueryStandardDataByEvaluateComRespDto> batchQueryStandardDataByEvaluateCom(@RequestBody @Validated BatchQueryStandardDataByEvaluateComReqDto reqDTO){
    return OkrResult.success(standardDataService.batchQueryStandardDataByEvaluateCom(reqDTO));
    }

/**
   * D4-1提交标准数据(公共)
   */
    @PostMapping("commitStandardDataCom")
    public OkrResult<CommitStandardDataComRespDto> commitStandardDataCom(@RequestBody @Validated CommitStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.commitStandardDataCom(reqDTO));
    }
/**
   * D4-查询时间范围标准数据列表(公共)
   */
    @PostMapping("queryTimeRangeStandardDataListCom")
    public OkrResult<QueryTimeRangeStandardDataListComRespDto> queryTimeRangeStandardDataListCom(@RequestBody @Validated QueryTimeRangeStandardDataListComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryTimeRangeStandardDataListCom(reqDTO));
    }
/**
   * D4-查询实时得分等级详情(公共)
   */
    @PostMapping("queryRealTimeScoreClassDetailCom")
    public OkrResult<QueryRealTimeScoreClassDetailComRespDto> queryRealTimeScoreClassDetailCom(@RequestBody @Validated QueryRealTimeScoreClassDetailComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryRealTimeScoreClassDetailCom(reqDTO));
    }
/**
   * D4-审核通过标准数据(公共)
   */
    @PostMapping("approveSucceedStandardDataCom")
    public OkrResult<ApproveSucceedStandardDataComRespDto> approveSucceedStandardDataCom(@RequestBody @Validated ApproveSucceedStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.approveSucceedStandardDataCom(reqDTO));
    }
/**
   * D4-批量查询实时得分等级(公共)
   */
    @PostMapping("batchQueryRealTimeScoreClassCom")
    public OkrResult<BatchQueryRealTimeScoreClassComRespDto> batchQueryRealTimeScoreClassCom(@RequestBody @Validated BatchQueryRealTimeScoreClassComReqDto reqDTO){
    return OkrResult.success(standardDataService.batchQueryRealTimeScoreClassCom(reqDTO));
    }

/**
   * D4-查询最近可循环周期标准数据列表(公共)
   */
    @PostMapping("queryNextCyclePeriodStandardDataListCom")
    public OkrResult<QueryNextCyclePeriodStandardDataListComRespDto> queryNextCyclePeriodStandardDataListCom(@RequestBody @Validated QueryNextCyclePeriodStandardDataListComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryNextCyclePeriodStandardDataListCom(reqDTO));
    }
/**
   * D4-计算汇报平均分标准数据(公共)
   */
    @PostMapping("calculateAvgReportScoreStandardDataCom")
    public OkrResult<CalculateAvgReportScoreStandardDataComRespDto> calculateAvgReportScoreStandardDataCom(@RequestBody @Validated CalculateAvgReportScoreStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateAvgReportScoreStandardDataCom(reqDTO));
    }
/**
   * D4-计算并新增周期汇报平均分标准数据(公共)
   */
    @PostMapping("calculateAndCreateAvgReportScoreStandardDataCom")
    public OkrResult<CalculateAndCreateAvgReportScoreStandardDataComRespDto> calculateAndCreateAvgReportScoreStandardDataCom(@RequestBody @Validated CalculateAndCreateAvgReportScoreStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateAndCreateAvgReportScoreStandardDataCom(reqDTO));
    }
/**
   * D4-计算并新增父周期过程汇报得分标准数据(公共)
   */
    @PostMapping("calculateAndCreateFatherProcessReportScoreStandardDataCom")
    public OkrResult<CalculateAndCreateFatherProcessReportScoreStandardDataComRespDto> calculateAndCreateFatherProcessReportScoreStandardDataCom(@RequestBody @Validated CalculateAndCreateFatherProcessReportScoreStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateAndCreateFatherProcessReportScoreStandardDataCom(reqDTO));
    }
/**
   * D4-计算并新增中期过程汇报得分标准数据(公共)
   */
    @PostMapping("calculateAndCreateMidProcessReportScoreStandardDataCom")
    public OkrResult<CalculateAndCreateMidProcessReportScoreStandardDataComRespDto> calculateAndCreateMidProcessReportScoreStandardDataCom(@RequestBody @Validated CalculateAndCreateMidProcessReportScoreStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateAndCreateMidProcessReportScoreStandardDataCom(reqDTO));
    }
/**
   * D4-计算并新增子周期过程汇报得分标准数据(公共)
   */
    @PostMapping("calculateAndCreateSubProcessReportScoreStandardDataCom")
    public OkrResult<CalculateAndCreateSubProcessReportScoreStandardDataComRespDto> calculateAndCreateSubProcessReportScoreStandardDataCom(@RequestBody @Validated CalculateAndCreateSubProcessReportScoreStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateAndCreateSubProcessReportScoreStandardDataCom(reqDTO));
    }
/**
   * D4-计算过程汇报得分标准数据(公共)
   */
    @PostMapping("calculateProcessReportScoreStandardDataCom")
    public OkrResult<CalculateProcessReportScoreStandardDataComRespDto> calculateProcessReportScoreStandardDataCom(@RequestBody @Validated CalculateProcessReportScoreStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateProcessReportScoreStandardDataCom(reqDTO));
    }
/**
   * D4-计算子周期汇报得分标准数据(公共)
   */
    @PostMapping("calculateSubReportScoreStandardDataCom")
    public OkrResult<CalculateSubReportScoreStandardDataComRespDto> calculateSubReportScoreStandardDataCom(@RequestBody @Validated CalculateSubReportScoreStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateSubReportScoreStandardDataCom(reqDTO));
    }
/**
   * D4-计算并新增人工汇报得分标准数据(公共)
   */
    @PostMapping("calculateAndCreateManualReportScoreStandardDataCom")
    public OkrResult<CalculateAndCreateManualReportScoreStandardDataComRespDto> calculateAndCreateManualReportScoreStandardDataCom(@RequestBody @Validated CalculateAndCreateManualReportScoreStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateAndCreateManualReportScoreStandardDataCom(reqDTO));
    }
/**
   * D4-计算并新增自动汇报得分标准数据(公共)
   */
    @PostMapping("calculateAndCreateAutoReportScoreStandardDataCom")
    public OkrResult<CalculateAndCreateAutoReportScoreStandardDataComRespDto> calculateAndCreateAutoReportScoreStandardDataCom(@RequestBody @Validated CalculateAndCreateAutoReportScoreStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateAndCreateAutoReportScoreStandardDataCom(reqDTO));
    }
/**
   * D4-查询计算准备的下级权重及标准数据列表(公共)
   */
    @PostMapping("queryPrepareForLowWeightAndDataListCom")
    public OkrResult<QueryPrepareForLowWeightAndDataListComRespDto> queryPrepareForLowWeightAndDataListCom(@RequestBody @Validated QueryPrepareForLowWeightAndDataListComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryPrepareForLowWeightAndDataListCom(reqDTO));
    }


/**
   * D4-计算过程周期汇报得分标准数据(公共)
   */
    @PostMapping("calculateProcessCycleReportScoreStandardDataCom")
    public OkrResult<CalculateProcessCycleReportScoreStandardDataComRespDto> calculateProcessCycleReportScoreStandardDataCom(@RequestBody @Validated CalculateProcessCycleReportScoreStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateProcessCycleReportScoreStandardDataCom(reqDTO));
    }
/**
   * D4-计算父周期汇报得分标准数据(公共)
   */
    @PostMapping("calculateFatherReportScoreStandardDataCom")
    public OkrResult<CalculateFatherReportScoreStandardDataComRespDto> calculateFatherReportScoreStandardDataCom(@RequestBody @Validated CalculateFatherReportScoreStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateFatherReportScoreStandardDataCom(reqDTO));
    }
/**
   * D4-计算中期汇报得分标准数据(公共)
   */
    @PostMapping("calculateMidReportScoreStandardDataCom")
    public OkrResult<CalculateMidReportScoreStandardDataComRespDto> calculateMidReportScoreStandardDataCom(@RequestBody @Validated CalculateMidReportScoreStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateMidReportScoreStandardDataCom(reqDTO));
    }

/**
   * D4-计算汇报得分标准数据(公共)
   */
    @PostMapping("calculateReportScoreStandardDataCom")
    public OkrResult<CalculateReportScoreStandardDataComRespDto> calculateReportScoreStandardDataCom(@RequestBody @Validated CalculateReportScoreStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateReportScoreStandardDataCom(reqDTO));
    }

/**
   * D4-计算并新增参照实际值标准数据(公共)
   */
    @PostMapping("calculateAndCreateCountActualValueDataCom")
    public OkrResult<CalculateAndCreateCountActualValueDataComRespDto> calculateAndCreateCountActualValueDataCom(@RequestBody @Validated CalculateAndCreateCountActualValueDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateAndCreateCountActualValueDataCom(reqDTO));
    }
/**
   * D4-计算并新增参照进度值标准数据(公共)
   */
    @PostMapping("calculateAndCreateCountProgressStandardDataCom")
    public OkrResult<CalculateAndCreateCountProgressStandardDataComRespDto> calculateAndCreateCountProgressStandardDataCom(@RequestBody @Validated CalculateAndCreateCountProgressStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateAndCreateCountProgressStandardDataCom(reqDTO));
    }
/**
   * D4-计算较上次变化值及增降幅标准数据(公共)
   */
    @PostMapping("calculateChangeFromLastAndFromLastRatioStandardDataCom")
    public OkrResult<CalculateChangeFromLastAndFromLastRatioStandardDataComRespDto> calculateChangeFromLastAndFromLastRatioStandardDataCom(@RequestBody @Validated CalculateChangeFromLastAndFromLastRatioStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateChangeFromLastAndFromLastRatioStandardDataCom(reqDTO));
    }
/**
   * D4-计算参照进度值标准数据(公共)
   */
    @PostMapping("calculateCountProgressStandardDataCom")
    public OkrResult<CalculateCountProgressStandardDataComRespDto> calculateCountProgressStandardDataCom(@RequestBody @Validated CalculateCountProgressStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateCountProgressStandardDataCom(reqDTO));
    }

/**
   * D4-计算实际值标准数据(公共)
   */
    @PostMapping("calculateActualValueDataCom")
    public OkrResult<CalculateActualValueDataComRespDto> calculateActualValueDataCom(@RequestBody @Validated CalculateActualValueDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateActualValueDataCom(reqDTO));
    }
/**
   * D4-计算进度值标准数据(公共)
   */
    @PostMapping("calculateProgressStandardDataCom")
    public OkrResult<CalculateProgressStandardDataComRespDto> calculateProgressStandardDataCom(@RequestBody @Validated CalculateProgressStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateProgressStandardDataCom(reqDTO));
    }


/**
   * D4-执行计算中间周期汇报得分
   */
    @PostMapping("calculateAndCreateNotLastReportScoreStandardDataCom")
    public OkrResult<CalculateAndCreateNotLastReportScoreStandardDataComRespDto> calculateAndCreateNotLastReportScoreStandardDataCom(@RequestBody @Validated CalculateAndCreateNotLastReportScoreStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateAndCreateNotLastReportScoreStandardDataCom(reqDTO));
    }
/**
   * D4-计算主客观得分
   */
    @PostMapping("calculateSubjectiveAndObjectiveStandardDataCom")
    public OkrResult<CalculateSubjectiveAndObjectiveStandardDataComRespDto> calculateSubjectiveAndObjectiveStandardDataCom(@RequestBody @Validated CalculateSubjectiveAndObjectiveStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateSubjectiveAndObjectiveStandardDataCom(reqDTO));
    }
/**
   * D4-计算父周期实际得分（及达成度）
   */
    @PostMapping("calculateFatherScoreAndReachStandardDataCom")
    public OkrResult<CalculateFatherScoreAndReachStandardDataComRespDto> calculateFatherScoreAndReachStandardDataCom(@RequestBody @Validated CalculateFatherScoreAndReachStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateFatherScoreAndReachStandardDataCom(reqDTO));
    }
/**
   * D4-计算中期实际得分（及达成度）
   */
    @PostMapping("calculateMidScoreAndReachStandardDataCom")
    public OkrResult<CalculateMidScoreAndReachStandardDataComRespDto> calculateMidScoreAndReachStandardDataCom(@RequestBody @Validated CalculateMidScoreAndReachStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateMidScoreAndReachStandardDataCom(reqDTO));
    }
/**
   * D4-计算子周期实际得分（及达成度）
   */
    @PostMapping("calculateSubScoreAndReachStandardDataCom")
    public OkrResult<CalculateSubScoreAndReachStandardDataComRespDto> calculateSubScoreAndReachStandardDataCom(@RequestBody @Validated CalculateSubScoreAndReachStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateSubScoreAndReachStandardDataCom(reqDTO));
    }


/**
   * 1111D4-查询向上计算目标跟节点详情(公共)
   */
    @PostMapping("queryUpCalcTargetDetailCom")
    public OkrResult<QueryUpCalcTargetDetailComRespDto> queryUpCalcTargetDetailCom(@RequestBody @Validated QueryUpCalcTargetDetailComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryUpCalcTargetDetailCom(reqDTO));
    }

/**
   * D4-克隆当前树到其他树（标准数据）
   */
    @PostMapping("cloneOtherTreeStandardDataCom")
    public OkrResult<CloneOtherTreeStandardDataComRespDto> cloneOtherTreeStandardDataCom(@RequestBody @Validated CloneOtherTreeStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.cloneOtherTreeStandardDataCom(reqDTO));
    }
/**
   * D4-计算参照值
   */
    @PostMapping("calculateLowerLevelObjectCom")
    public OkrResult<CalculateLowerLevelObjectComRespDto> calculateLowerLevelObjectCom(@RequestBody @Validated CalculateLowerLevelObjectComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateLowerLevelObjectCom(reqDTO));
    }
/**
   * D4-人工汇报计算参照进度值
   */
    @PostMapping("calculateCountProgressStandardDataComBak")
    public OkrResult<CalculateCountProgressStandardDataComBakRespDto> calculateCountProgressStandardDataComBak(@RequestBody @Validated CalculateCountProgressStandardDataComBakReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateCountProgressStandardDataComBak(reqDTO));
    }
/**
   * D4-执行计算参照进度值（O&KR）
   */
    @PostMapping("calculateCountProgressByOAndKRCom")
    public OkrResult<CalculateCountProgressByOAndKRComRespDto> calculateCountProgressByOAndKRCom(@RequestBody @Validated CalculateCountProgressByOAndKRComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateCountProgressByOAndKRCom(reqDTO));
    }
/**
   * D4-执向右计算实际值
   */
    @PostMapping("implementCrossCycleActualValueStandardDataCom")
    public OkrResult<ImplementCrossCycleActualValueStandardDataComRespDto> implementCrossCycleActualValueStandardDataCom(@RequestBody @Validated ImplementCrossCycleActualValueStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.implementCrossCycleActualValueStandardDataCom(reqDTO));
    }


/**
   * D4-执行克隆当前树数据
   */
    @PostMapping("implementOtherTreeStandardDataCom")
    public OkrResult<ImplementOtherTreeStandardDataComRespDto> implementOtherTreeStandardDataCom(@RequestBody @Validated ImplementOtherTreeStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.implementOtherTreeStandardDataCom(reqDTO));
    }
/**
   * D4-统一更新标准数据(公共)
   */
    @PostMapping("unifiedRefreshStandardDataCom")
    public OkrResult<UnifiedRefreshStandardDataComRespDto> unifiedRefreshStandardDataCom(@RequestBody @Validated UnifiedRefreshStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.unifiedRefreshStandardDataCom(reqDTO));
    }
///**
//   * D4-查询计算准备的内容信息详情(公共)
//   */
//    @PostMapping("queryDetailCom")
//    public OkrResult<QueryDetailComRespDto> queryDetailCom(@RequestBody @Validated QueryDetailComReqDto reqDTO){
//    return OkrResult.success(standardDataService.queryDetailCom(reqDTO));
//    }
/**
   * D4-查询上一执行周期标准数据详情(公共)
   */
    @PostMapping("queryLastCyclestandardDataDetailCom")
    public OkrResult<QueryLastCyclestandardDataDetailComRespDto> queryLastCyclestandardDataDetailCom(@RequestBody @Validated QueryLastCyclestandardDataDetailComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryLastCyclestandardDataDetailCom(reqDTO));
    }
/**
   * D4-查询参照值准备的标准数据详情(公共)
   */
    @PostMapping("queryPrepareForReferenceStandardDataDetailCom")
    public OkrResult<QueryPrepareForReferenceStandardDataDetailComRespDto> queryPrepareForReferenceStandardDataDetailCom(@RequestBody @Validated QueryPrepareForReferenceStandardDataDetailComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryPrepareForReferenceStandardDataDetailCom(reqDTO));
    }
/**
   * D4-执行标准数据单位分析1
   */
    @PostMapping("implementStandardDataUnitCom")
    public OkrResult<ImplementStandardDataUnitComRespDto> implementStandardDataUnitCom(@RequestBody @Validated ImplementStandardDataUnitComReqDto reqDTO){
    return OkrResult.success(standardDataService.implementStandardDataUnitCom(reqDTO));
    }
/**
   * D4-计算下级得分（公共）
   */
    @PostMapping("calculateLowerLevelScoreStandardDataCom")
    public OkrResult<CalculateLowerLevelScoreStandardDataComRespDto> calculateLowerLevelScoreStandardDataCom(@RequestBody @Validated CalculateLowerLevelScoreStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateLowerLevelScoreStandardDataCom(reqDTO));
    }
/**
   * D4-执行计算过程周期汇报得分(公共)
   */
    @PostMapping("implementProcessCycleReportScoreStandardDataCom")
    public OkrResult<ImplementProcessCycleReportScoreStandardDataComRespDto> implementProcessCycleReportScoreStandardDataCom(@RequestBody @Validated ImplementProcessCycleReportScoreStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.implementProcessCycleReportScoreStandardDataCom(reqDTO));
    }
/**
   * D4-查询计算准备的内容信息详情(公共)
   */
    @PostMapping("queryPrepareForCalcContentDetailCom")
    public OkrResult<QueryPrepareForCalcContentDetailComRespDto> queryPrepareForCalcContentDetailCom(@RequestBody @Validated QueryPrepareForCalcContentDetailComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryPrepareForCalcContentDetailCom(reqDTO));
    }
/**
   * D4-执行克隆四棵树数据类型分析
   */
    @PostMapping("implementPrepareForOtherTreeCom")
    public OkrResult<ImplementPrepareForOtherTreeComRespDto> implementPrepareForOtherTreeCom(@RequestBody @Validated ImplementPrepareForOtherTreeComReqDto reqDTO){
    return OkrResult.success(standardDataService.implementPrepareForOtherTreeCom(reqDTO));
    }
/**
   * D4-查询高中基工作周期使用标准数据列表(公共)
   */
    @PostMapping("queryHighMidBaseWorkCycleDataListCom")
    public OkrResult<QueryHighMidBaseWorkCycleDataListComRespDto> queryHighMidBaseWorkCycleDataListCom(@RequestBody @Validated QueryHighMidBaseWorkCycleDataListComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryHighMidBaseWorkCycleDataListCom(reqDTO));
    }
/**
   * D4-查询高中基使用标准数据列表(公共)
   */
    @PostMapping("queryHighMidBaseStandardDataListCom")
    public OkrResult<QueryHighMidBaseStandardDataListComRespDto> queryHighMidBaseStandardDataListCom(@RequestBody @Validated QueryHighMidBaseStandardDataListComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryHighMidBaseStandardDataListCom(reqDTO));
    }
/**
   * D4-查询高中基使用标准数据详情(公共)
   */
    @PostMapping("queryHighMidBaseStandardDataDetailCom")
    public OkrResult<QueryHighMidBaseStandardDataDetailComRespDto> queryHighMidBaseStandardDataDetailCom(@RequestBody @Validated QueryHighMidBaseStandardDataDetailComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryHighMidBaseStandardDataDetailCom(reqDTO));
    }
/**
   * D4-查询目标周期汇报单条数据(公共)
   */
    @PostMapping("queryEvaObjTargetCycleSingleDetailDataDetailCom")
    public OkrResult<QueryEvaObjTargetCycleSingleDetailDataDetailComRespDto> queryEvaObjTargetCycleSingleDetailDataDetailCom(@RequestBody @Validated QueryEvaObjTargetCycleSingleDetailDataDetailComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryEvaObjTargetCycleSingleDetailDataDetailCom(reqDTO));
    }
/**
   * D4-1批量查询标准数据列表(公共)
   */
    @PostMapping("batchQueryStandardDataCom")
    public OkrResult<BatchQueryStandardDataComRespDto> batchQueryStandardDataCom(@RequestBody @Validated BatchQueryStandardDataComReqDto reqDTO){
    Page<?> page = CommonFunctionHelper.startPage(reqDTO.getPageNum(),reqDTO.getPageSize());

        BatchQueryStandardDataComRespDto retData = standardDataService.batchQueryStandardDataCom(reqDTO);

        retData.setPageNum(page.getPageNum());
        retData.setPageSize(page.getPageSize());
        retData.setTotalNum(page.getTotal());
        return OkrResult.success(retData);

    }

/**
   * D4执行任务书同级叶子是否完成分析(公共)
   */
    @PostMapping("implementTaskBookBrotherLeafFfnishCom")
    public OkrResult<ImplementTaskBookBrotherLeafFfnishComRespDto> implementTaskBookBrotherLeafFfnishCom(@RequestBody @Validated ImplementTaskBookBrotherLeafFfnishComReqDto reqDTO){
    return OkrResult.success(standardDataService.implementTaskBookBrotherLeafFfnishCom(reqDTO));
    }
/**
   * D4执行同级兄弟数据更新分析(公共)
   */
    @PostMapping("implementSiblingBrotherDataUpdateAnalysisCom")
    public OkrResult<ImplementSiblingBrotherDataUpdateAnalysisComRespDto> implementSiblingBrotherDataUpdateAnalysisCom(@RequestBody @Validated ImplementSiblingBrotherDataUpdateAnalysisComReqDto reqDTO){
    return OkrResult.success(standardDataService.implementSiblingBrotherDataUpdateAnalysisCom(reqDTO));
    }
/**
   * D4-查询计算准备的配置详情(公共)
   */
    @PostMapping("queryPrepareForCalcConfDetailCom")
    public OkrResult<QueryPrepareForCalcConfDetailComRespDto> queryPrepareForCalcConfDetailCom(@RequestBody @Validated QueryPrepareForCalcConfDetailComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryPrepareForCalcConfDetailCom(reqDTO));
    }


/**
   * D4-计算当前进度值相关(公共)
   */
    @PostMapping("calculateFirstContOtherTreeProgressCom")
    public OkrResult<CalculateFirstContOtherTreeProgressComRespDto> calculateFirstContOtherTreeProgressCom(@RequestBody @Validated CalculateFirstContOtherTreeProgressComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateFirstContOtherTreeProgressCom(reqDTO));
    }
/**
   * D4-计算第一张牌其他树实际值(公共)
   */
    @PostMapping("calculateFirstContOtherTreeActualCom")
    public OkrResult<CalculateFirstContOtherTreeActualComRespDto> calculateFirstContOtherTreeActualCom(@RequestBody @Validated CalculateFirstContOtherTreeActualComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateFirstContOtherTreeActualCom(reqDTO));
    }



/**
   * D4-计算进度值准备的内容数据(公共)
   */
    @PostMapping("calculatePrepareForProcessContentDataCom")
    public OkrResult<CalculatePrepareForProcessContentDataComRespDto> calculatePrepareForProcessContentDataCom(@RequestBody @Validated CalculatePrepareForProcessContentDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculatePrepareForProcessContentDataCom(reqDTO));
    }
/**
   * D4-计算进度值准备的周期数据(公共)
   */
    @PostMapping("calculatePrepareForProcessCycleDataCom")
    public OkrResult<CalculatePrepareForProcessCycleDataComRespDto> calculatePrepareForProcessCycleDataCom(@RequestBody @Validated CalculatePrepareForProcessCycleDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculatePrepareForProcessCycleDataCom(reqDTO));
    }
/**
   * D4-跨树计算下级KR实际得分(公共)
   */
    @PostMapping("calculateLowKRActualScoreStandardDataCom")
    public OkrResult<CalculateLowKRActualScoreStandardDataComRespDto> calculateLowKRActualScoreStandardDataCom(@RequestBody @Validated CalculateLowKRActualScoreStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateLowKRActualScoreStandardDataCom(reqDTO));
    }
/**
   * D4-跨树计算实际得分(公共)
   */
    @PostMapping("calculateOtherTreeActualScoreStandardDataCom")
    public OkrResult<CalculateOtherTreeActualScoreStandardDataComRespDto> calculateOtherTreeActualScoreStandardDataCom(@RequestBody @Validated CalculateOtherTreeActualScoreStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateOtherTreeActualScoreStandardDataCom(reqDTO));
    }
/**
   * D4-查询计算准备的上级目标周期列表列表(公共)
   */
    @PostMapping("queryPrepareForEvaObjTargetCycleListListCom")
    public OkrResult<QueryPrepareForEvaObjTargetCycleListListComRespDto> queryPrepareForEvaObjTargetCycleListListCom(@RequestBody @Validated QueryPrepareForEvaObjTargetCycleListListComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryPrepareForEvaObjTargetCycleListListCom(reqDTO));
    }



/**
   * D4-执行最近可循环周期标准数据分析(公共)
   */
    @PostMapping("implementNextCyclePeriodStandardDataCom")
    public OkrResult<ImplementNextCyclePeriodStandardDataComRespDto> implementNextCyclePeriodStandardDataCom(@RequestBody @Validated ImplementNextCyclePeriodStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.implementNextCyclePeriodStandardDataCom(reqDTO));
    }
/**
   * D4-计算向右周期实际值(公共)
   */
    @PostMapping("calculateCrossCycleActualValueCom")
    public OkrResult<CalculateCrossCycleActualValueComRespDto> calculateCrossCycleActualValueCom(@RequestBody @Validated CalculateCrossCycleActualValueComReqDto reqDTO){
    return OkrResult.success(standardDataService.calculateCrossCycleActualValueCom(reqDTO));
    }
/**
   * D4-执行父子中周期类型分析(公共)
   */
    @PostMapping("implementParentSubMidCycleTypeAnalysisCom")
    public OkrResult<ImplementParentSubMidCycleTypeAnalysisComRespDto> implementParentSubMidCycleTypeAnalysisCom(@RequestBody @Validated ImplementParentSubMidCycleTypeAnalysisComReqDto reqDTO){
    return OkrResult.success(standardDataService.implementParentSubMidCycleTypeAnalysisCom(reqDTO));
    }
/**
   * D4-执行跨树父子中周期类型分析(公共)
   */
    @PostMapping("implementOtherTreeParentSubMidCycleTypeAnalysisCom")
    public OkrResult<ImplementOtherTreeParentSubMidCycleTypeAnalysisComRespDto> implementOtherTreeParentSubMidCycleTypeAnalysisCom(@RequestBody @Validated ImplementOtherTreeParentSubMidCycleTypeAnalysisComReqDto reqDTO){
    return OkrResult.success(standardDataService.implementOtherTreeParentSubMidCycleTypeAnalysisCom(reqDTO));
    }
/**
   * D4-更新标准数据是否最新标识(公共)
   */
    @PostMapping("implementUpdateStandardDataCom")
    public OkrResult<ImplementUpdateStandardDataComRespDto> implementUpdateStandardDataCom(@RequestBody @Validated ImplementUpdateStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.implementUpdateStandardDataCom(reqDTO));
    }
/**
   * D4-通过工作周期更新切片查询标准数据列表(公共)
   */
    @PostMapping("queryStandardDataByWorkCycleUpdateSliceListCom")
    public OkrResult<QueryStandardDataByWorkCycleUpdateSliceListComRespDto> queryStandardDataByWorkCycleUpdateSliceListCom(@RequestBody @Validated QueryStandardDataByWorkCycleUpdateSliceListComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryStandardDataByWorkCycleUpdateSliceListCom(reqDTO));
    }
/**
   * D4-提交非末级周期提交标准数据(公共)
   */
    @PostMapping("commitNotLastCycleCommitStandardDataCom")
    public OkrResult<CommitNotLastCycleCommitStandardDataComRespDto> commitNotLastCycleCommitStandardDataCom(@RequestBody @Validated CommitNotLastCycleCommitStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.commitNotLastCycleCommitStandardDataCom(reqDTO));
    }
/**
   * D4批量删被评对象目标周期标准数据(公共)
   */
    @PostMapping("batchDeleteEvaObjTargetCycleDataCom")
    public OkrResult<BatchDeleteEvaObjTargetCycleDataComRespDto> batchDeleteEvaObjTargetCycleDataCom(@RequestBody @Validated BatchDeleteEvaObjTargetCycleDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.batchDeleteEvaObjTargetCycleDataCom(reqDTO));
    }
/**
   * D4-查询向右周期实际值详情(公共)
   */
    @PostMapping("queryRightCycleActualValueDataDetailCom")
    public OkrResult<QueryRightCycleActualValueDataDetailComRespDto> queryRightCycleActualValueDataDetailCom(@RequestBody @Validated QueryRightCycleActualValueDataDetailComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryRightCycleActualValueDataDetailCom(reqDTO));
    }
/**
   * D4-查询向右周期详情(公共)
   */
    @PostMapping("queryRightCycleDetailCom")
    public OkrResult<QueryRightCycleDetailComRespDto> queryRightCycleDetailCom(@RequestBody @Validated QueryRightCycleDetailComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryRightCycleDetailCom(reqDTO));
    }

    /**
     * D4-查询向右周期详情(公共)
     */
    @PostMapping("queryStandardDataByUpdateCycleTimeRangeListComTest")
    public OkrResult<QueryStandardDataByUpdateCycleTimeRangeListComTestRespDto> queryStandardDataByUpdateCycleTimeRangeListComTest(@RequestBody @Validated QueryStandardDataByUpdateCycleTimeRangeListComTestReqDto reqDTO){
        return OkrResult.success(standardDataService.queryStandardDataByUpdateCycleTimeRangeListComTest(reqDTO));
    }
/**
   * D4-更新周期时间范围查标准数据列表(公共)
   */
    @PostMapping("queryStandardDataByUpdateCycleTimeRangeListCom")
    public OkrResult<QueryStandardDataByUpdateCycleTimeRangeListComRespDto> queryStandardDataByUpdateCycleTimeRangeListCom(@RequestBody @Validated QueryStandardDataByUpdateCycleTimeRangeListComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryStandardDataByUpdateCycleTimeRangeListCom(reqDTO));
    }
/**
   * D4-执行向左计算并新增标准数据(公共)
   */
    @PostMapping("implementCalcRightCycleActualValueCom")
    public OkrResult<ImplementCalcRightCycleActualValueComRespDto> implementCalcRightCycleActualValueCom(@RequestBody @Validated ImplementCalcRightCycleActualValueComReqDto reqDTO){
    return OkrResult.success(standardDataService.implementCalcRightCycleActualValueCom(reqDTO));
    }
/**
   * D4批量存档标准数据(公共)
   */
    @PostMapping("batchArchiveStandardDataCom")
    public OkrResult<BatchArchiveStandardDataComRespDto> batchArchiveStandardDataCom(@RequestBody @Validated BatchArchiveStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.batchArchiveStandardDataCom(reqDTO));
    }
/**
   * D4执行标准数据集过滤指定数据(公共)
   */
    @PostMapping("implementStandardDataFilterSpecRecCom")
    public OkrResult<ImplementStandardDataFilterSpecRecComRespDto> implementStandardDataFilterSpecRecCom(@RequestBody @Validated ImplementStandardDataFilterSpecRecComReqDto reqDTO){
    return OkrResult.success(standardDataService.implementStandardDataFilterSpecRecCom(reqDTO));
    }
/**
   * D4执行目标父中周期预算标准数据(公共)
   */
    @PostMapping("implementAddTargetParentMidCycleBudgetDataCom")
    public OkrResult<ImplementAddTargetParentMidCycleBudgetDataComRespDto> implementAddTargetParentMidCycleBudgetDataCom(@RequestBody @Validated ImplementAddTargetParentMidCycleBudgetDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.implementAddTargetParentMidCycleBudgetDataCom(reqDTO));
    }
/**
   * D4执行循环增目标子周期预算标准数据(公共)
   */
    @PostMapping("implementLoopAddTargetSubCycleBudgetDataCom")
    public OkrResult<ImplementLoopAddTargetSubCycleBudgetDataComRespDto> implementLoopAddTargetSubCycleBudgetDataCom(@RequestBody @Validated ImplementLoopAddTargetSubCycleBudgetDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.implementLoopAddTargetSubCycleBudgetDataCom(reqDTO));
    }
/**
   * D4执行循环增祖先目标内容目标周期预算标准数据(公共)
   */
    @PostMapping("implementLoopAddAncestorContTargetCycleBudgetDataCom")
    public OkrResult<ImplementLoopAddAncestorContTargetCycleBudgetDataComRespDto> implementLoopAddAncestorContTargetCycleBudgetDataCom(@RequestBody @Validated ImplementLoopAddAncestorContTargetCycleBudgetDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.implementLoopAddAncestorContTargetCycleBudgetDataCom(reqDTO));
    }
/**
   * D4查工作周期来源预算资金标准数据列表(公共)
   */
    @PostMapping("queryWorkCycleSourceBudgetFundStandardDataListCom")
    public OkrResult<QueryWorkCycleSourceBudgetFundStandardDataListComRespDto> queryWorkCycleSourceBudgetFundStandardDataListCom(@RequestBody @Validated QueryWorkCycleSourceBudgetFundStandardDataListComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryWorkCycleSourceBudgetFundStandardDataListCom(reqDTO));
    }
/**
   * D4执行循环增目标子周期预算占比标准数据(公共)
   */
    @PostMapping("implementLoopAddSubCycleBudgetPropStandardDataCom")
    public OkrResult<ImplementLoopAddSubCycleBudgetPropStandardDataComRespDto> implementLoopAddSubCycleBudgetPropStandardDataCom(@RequestBody @Validated ImplementLoopAddSubCycleBudgetPropStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.implementLoopAddSubCycleBudgetPropStandardDataCom(reqDTO));
    }
/**
   * D4-更新自动汇报更新标准数据(公共)
   */
    @PostMapping("refreshAutoReportStandardDataCom")
    public OkrResult<RefreshAutoReportStandardDataComRespDto> refreshAutoReportStandardDataCom(@RequestBody @Validated RefreshAutoReportStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.refreshAutoReportStandardDataCom(reqDTO));
    }
/**
   * D4执行数据值结果加减(公共)
   */
    @PostMapping("implementDataResultAddOrReductionCom")
    public OkrResult<ImplementDataResultAddOrReductionComRespDto> implementDataResultAddOrReductionCom(@RequestBody @Validated ImplementDataResultAddOrReductionComReqDto reqDTO){
    return OkrResult.success(standardDataService.implementDataResultAddOrReductionCom(reqDTO));
    }
/**
   * D4-提交汇报任务标准数据(公共)
   */
    @PostMapping("commitReportTaskStandardDataCom")
    public OkrResult<CommitReportTaskStandardDataComRespDto> commitReportTaskStandardDataCom(@RequestBody @Validated CommitReportTaskStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.commitReportTaskStandardDataCom(reqDTO));
    }
/**
   * D4-执行发布并托底计算标准数据(公共)
   */
    @PostMapping("implementExamineAndUnderpinCalcStandardDataCom")
    public OkrResult<ImplementExamineAndUnderpinCalcStandardDataComRespDto> implementExamineAndUnderpinCalcStandardDataCom(@RequestBody @Validated ImplementExamineAndUnderpinCalcStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.implementExamineAndUnderpinCalcStandardDataCom(reqDTO));
    }
/**
   * D4-托底更新财务标准数据(公共)
   */
    @PostMapping("bottomUpdateFinanceStandardDataCom")
    public OkrResult<BottomUpdateFinanceStandardDataComRespDto> bottomUpdateFinanceStandardDataCom(@RequestBody @Validated BottomUpdateFinanceStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.bottomUpdateFinanceStandardDataCom(reqDTO));
    }
/**
   * D4-获取Redis账户数据并新增标准数据(公共)
   */
    @PostMapping("addFinanceStandardDataCom")
    public OkrResult<AddFinanceStandardDataComRespDto> addFinanceStandardDataCom(@RequestBody @Validated AddFinanceStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.addFinanceStandardDataCom(reqDTO));
    }
/**
   * D4-更新刷标准数据填报评价责任人对象ID并清理垃圾数据（运维接口）(公共)
   */
    @PostMapping("refreshUpdateStandardDataPersonLiableObjIdCom")
    public OkrResult<RefreshUpdateStandardDataPersonLiableObjIdComRespDto> refreshUpdateStandardDataPersonLiableObjIdCom(@RequestBody @Validated RefreshUpdateStandardDataPersonLiableObjIdComReqDto reqDTO){
    Page<?> page = CommonFunctionHelper.startPage(reqDTO.getPageNum(),reqDTO.getPageSize());

        RefreshUpdateStandardDataPersonLiableObjIdComRespDto retData = standardDataService.refreshUpdateStandardDataPersonLiableObjIdCom(reqDTO);

        retData.setPageNum(page.getPageNum());
        retData.setPageSize(page.getPageSize());
        retData.setTotalNum(page.getTotal());
        return OkrResult.success(retData);

    }
/**
   * D4准备上一标准数据结果(公共)
   */
    @PostMapping("preparationPreviousStandardDataResultCom")
    public OkrResult<PreparationPreviousStandardDataResultComRespDto> preparationPreviousStandardDataResultCom(@RequestBody @Validated PreparationPreviousStandardDataResultComReqDto reqDTO){
    return OkrResult.success(standardDataService.preparationPreviousStandardDataResultCom(reqDTO));
    }
/**
   * D4生成标准数据(公共)
   */
    @PostMapping("generateStandardDataCom")
    public OkrResult<GenerateStandardDataComRespDto> generateStandardDataCom(@RequestBody @Validated GenerateStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.generateStandardDataCom(reqDTO));
    }
/**
   * D4更新数据点标准数据(公共)
   */
    @PostMapping("refreshDataPointStandardDataCom")
    public OkrResult<RefreshDataPointStandardDataComRespDto> refreshDataPointStandardDataCom(@RequestBody @Validated RefreshDataPointStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.refreshDataPointStandardDataCom(reqDTO));
    }
/**
   * D4审核当前内容标准数据(公共)
   */
    @PostMapping("implementApprovecurrentContentStandardDataCom")
    public OkrResult<ImplementApprovecurrentContentStandardDataComRespDto> implementApprovecurrentContentStandardDataCom(@RequestBody @Validated ImplementApprovecurrentContentStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.implementApprovecurrentContentStandardDataCom(reqDTO));
    }
/**
   * D4托底更新模板下全部标准数据(公共)
   */
    @PostMapping("bottomUpdateEvaluationStandardDataCom")
    public OkrResult<BottomUpdateEvaluationStandardDataComRespDto> bottomUpdateEvaluationStandardDataCom(@RequestBody @Validated BottomUpdateEvaluationStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.bottomUpdateEvaluationStandardDataCom(reqDTO));
    }
/**
   * D4查询归属主体标准数据列表(公共)
   */
    @PostMapping("queryStandardDataOfObjectListCom")
    public OkrResult<QueryStandardDataOfObjectListComRespDto> queryStandardDataOfObjectListCom(@RequestBody @Validated QueryStandardDataOfObjectListComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryStandardDataOfObjectListCom(reqDTO));
    }
/**
   * D4批量查询归属主体标准数据By归属内容表主键ID
   */
    @PostMapping("batchQueryStandardDataOfObjectCom")
    public OkrResult<BatchQueryStandardDataOfObjectComRespDto> batchQueryStandardDataOfObjectCom(@RequestBody @Validated BatchQueryStandardDataOfObjectComReqDto reqDTO){
    return OkrResult.success(standardDataService.batchQueryStandardDataOfObjectCom(reqDTO));
    }
/**
   * D4批量查询归属主体标准数据By数据归属内容表主键ID(公共)
   */
    @PostMapping("batchQueryStandardDataOfObjectByContentIdCom")
    public OkrResult<BatchQueryStandardDataOfObjectByContentIdComRespDto> batchQueryStandardDataOfObjectByContentIdCom(@RequestBody @Validated BatchQueryStandardDataOfObjectByContentIdComReqDto reqDTO){
    return OkrResult.success(standardDataService.batchQueryStandardDataOfObjectByContentIdCom(reqDTO));
    }
/**
   * D4批量查询归属主体标准数据By数据归属对象ID(公共)
   */
    @PostMapping("batchQueryStandardDataOfObjectByIdentityIdCom")
    public OkrResult<BatchQueryStandardDataOfObjectByIdentityIdComRespDto> batchQueryStandardDataOfObjectByIdentityIdCom(@RequestBody @Validated BatchQueryStandardDataOfObjectByIdentityIdComReqDto reqDTO){
    return OkrResult.success(standardDataService.batchQueryStandardDataOfObjectByIdentityIdCom(reqDTO));
    }
/**
   * D4查询归属主体标准数据详情(公共)
   */
    @PostMapping("queryStandardDataOfObjectDetailCom")
    public OkrResult<QueryStandardDataOfObjectDetailComRespDto> queryStandardDataOfObjectDetailCom(@RequestBody @Validated QueryStandardDataOfObjectDetailComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryStandardDataOfObjectDetailCom(reqDTO));
    }
/**
   * D4批量查询归属主体标准数据By数据点类型(公共)
   */
    @PostMapping("batchQueryStandardDataOfObjectByDataTypeCom")
    public OkrResult<BatchQueryStandardDataOfObjectByDataTypeComRespDto> batchQueryStandardDataOfObjectByDataTypeCom(@RequestBody @Validated BatchQueryStandardDataOfObjectByDataTypeComReqDto reqDTO){
    return OkrResult.success(standardDataService.batchQueryStandardDataOfObjectByDataTypeCom(reqDTO));
    }
/**
   * D4执行全模板目标计算标准数据(公共)
   */
    @PostMapping("implementFullEvaTempTargetCalcStandardDataCom")
    public OkrResult<ImplementFullEvaTempTargetCalcStandardDataComRespDto> implementFullEvaTempTargetCalcStandardDataCom(@RequestBody @Validated ImplementFullEvaTempTargetCalcStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.implementFullEvaTempTargetCalcStandardDataCom(reqDTO));
    }
/**
   * D4-1修改标准数据(公共)
   */
    @PostMapping("updateStandardDataCom")
    public OkrResult<UpdateStandardDataComRespDto> updateStandardDataCom(@RequestBody @Validated UpdateStandardDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.updateStandardDataCom(reqDTO));
    }

/**
   * D4查询标准数据悬停详情(公共)
   */
    @PostMapping("queryStandardDataHoverDetailCom")
    public OkrResult<QueryStandardDataHoverDetailComRespDto> queryStandardDataHoverDetailCom(@RequestBody @Validated QueryStandardDataHoverDetailComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryStandardDataHoverDetailCom(reqDTO));
    }
/**
   * D4执行回写标准数据周期阶段资料ID(公共)
   */
    @PostMapping("implementRewirteCycleStageDataIdCom")
    public OkrResult<ImplementRewirteCycleStageDataIdComRespDto> implementRewirteCycleStageDataIdCom(@RequestBody @Validated ImplementRewirteCycleStageDataIdComReqDto reqDTO){
    return OkrResult.success(standardDataService.implementRewirteCycleStageDataIdCom(reqDTO));
    }
/**
   * D4批量查询标准数据by周期阶段资料ID(公共)
   */
    @PostMapping("batchQueryStandardDataByCycleStageDataCom")
    public OkrResult<BatchQueryStandardDataByCycleStageDataComRespDto> batchQueryStandardDataByCycleStageDataCom(@RequestBody @Validated BatchQueryStandardDataByCycleStageDataComReqDto reqDTO){
    return OkrResult.success(standardDataService.batchQueryStandardDataByCycleStageDataCom(reqDTO));
    }
/**
   * D4执行分析并回写标准数据周期阶段资料ID(公共)
   */
    @PostMapping("implementAnalyzeAndRewirteCycleStageDataIdCom")
    public OkrResult<ImplementAnalyzeAndRewirteCycleStageDataIdComRespDto> implementAnalyzeAndRewirteCycleStageDataIdCom(@RequestBody @Validated ImplementAnalyzeAndRewirteCycleStageDataIdComReqDto reqDTO){
    return OkrResult.success(standardDataService.implementAnalyzeAndRewirteCycleStageDataIdCom(reqDTO));
    }
/**
   * D4批量查询标准数据列表异常场景(公共)
   */
    @PostMapping("batchQueryStandardDataListAbnormalCom")
    public OkrResult<BatchQueryStandardDataListAbnormalComRespDto> batchQueryStandardDataListAbnormalCom(@RequestBody @Validated BatchQueryStandardDataListAbnormalComReqDto reqDTO){
    return OkrResult.success(standardDataService.batchQueryStandardDataListAbnormalCom(reqDTO));
    }

/**
   * D4获取下级目标标准数据异常场景(公共)
   */
    @PostMapping("obtainLowStandardDataListAbnormCom")
    public OkrResult<ObtainLowStandardDataListAbnormComRespDto> obtainLowStandardDataListAbnormCom(@RequestBody @Validated ObtainLowStandardDataListAbnormComReqDto reqDTO){
    return OkrResult.success(standardDataService.obtainLowStandardDataListAbnormCom(reqDTO));
    }
/**
   * D4获取下级目标标准数据正常与异常场景(公共)
   */
    @PostMapping("obtainLowStandardDataListNormalAbnormCom")
    public OkrResult<ObtainLowStandardDataListNormalAbnormComRespDto> obtainLowStandardDataListNormalAbnormCom(@RequestBody @Validated ObtainLowStandardDataListNormalAbnormComReqDto reqDTO){
    return OkrResult.success(standardDataService.obtainLowStandardDataListNormalAbnormCom(reqDTO));
    }
/**
   * D4查询截止当前的实际值详情(公共)
   */
    @PostMapping("queryActualByCurrentDetailCom")
    public OkrResult<QueryActualByCurrentDetailComRespDto> queryActualByCurrentDetailCom(@RequestBody @Validated QueryActualByCurrentDetailComReqDto reqDTO){
    return OkrResult.success(standardDataService.queryActualByCurrentDetailCom(reqDTO));
    }
}
